package com.ruifu.proj.controller;

import com.fhzncloud.cloud.common.core.util.R;
import com.fhzncloud.cloud.common.security.service.CloudUser;
import com.fhzncloud.cloud.common.security.util.SecurityUtils;
import com.ruifu.common.po.PmPType;
import com.ruifu.common.vo.PageResultVO;
import com.ruifu.common.vo.ResultVO;
import com.ruifu.proj.dto.ptype.PmPTypeDTO;
import com.ruifu.proj.service.PmPTypeService;
import com.ruifu.proj.vo.pmptype.PmPTypeVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * 项目类型控制层
 *
 * @author 宁义锐
 */
@RestController
@CrossOrigin
@RequestMapping("/pmPType")
public class PmPTypeController {

    @Autowired
    private PmPTypeService pmPTypeService;

    /**
     * 用于存储登陆人信息
     */
    private CloudUser cloudUser;

    /**
     * 通过url请求方法之前,调用该方法获取登陆人信息
     */
    @ModelAttribute
    public void before() {
        cloudUser = SecurityUtils.getUser();
    }


    /**
     * 根据类别查询项目类型
     *
     * @param pyCode 类别编号
     * @return
     */
    @GetMapping(value = "/findByPyCode")
    public List<PmPTypeVO> findByPyCode(String pyCode) {
        return pmPTypeService.findByPyCode(pyCode, cloudUser);
    }


    /**
     * 分页查询项目类型
     *
     * @param pageNum  当前页码
     * @param pageSize 每页大小
     * @return
     */
    @GetMapping(value = "/findPage")
    public PageResultVO findPage(
            @RequestParam(defaultValue = "1") int pageNum,
            @RequestParam(defaultValue = "5") int pageSize) {
        //校验当前页码是否合理
        pageNum = pageNum <= 0 ? 1 : pageNum;
        //校验每页大小是否合理
        pageSize = pageSize < 5 ? 5 : pageSize;
        return pmPTypeService.findPage(pageNum, pageSize, cloudUser);
    }

    /**
     * 保存项目类型
     *
     * @param pmPTypeDTO 项目类型传输对象
     * @return
     */
    @PostMapping(value = "/insert")
    public ResultVO insert(@RequestBody PmPTypeDTO pmPTypeDTO) {
        try {
            pmPTypeService.insert(pmPTypeDTO, cloudUser);
            return new ResultVO(true, "新建成功");
        } catch (Exception e) {
            e.printStackTrace();
            return new ResultVO(false, "新建失败");
        }
    }

    /**
     * 新增
     *
     * @param pmPTypeDTO
     * @return
     */
    @PostMapping(value = "/add")
    public ResultVO add(@RequestBody PmPTypeDTO pmPTypeDTO) {
        try {
            pmPTypeService.add(pmPTypeDTO);
            return new ResultVO(true, "新建成功");
        } catch (Exception e) {
            e.printStackTrace();
            return new ResultVO(false, "新建失败");
        }
    }

    /**
     * 根据项目类型Id修改项目类型
     *
     * @param pmPTypeDTO 项目类型传输对象
     * @return
     */
    @PostMapping(value = "/updateById")
    public ResultVO updateById(@RequestBody PmPTypeDTO pmPTypeDTO) {
        try {
            pmPTypeService.updateById(pmPTypeDTO, cloudUser);
            return new ResultVO(true, "修改成功");
        } catch (Exception e) {
            e.printStackTrace();
            return new ResultVO(false, "修改失败");
        }
    }

    /**
     * 批量删除
     *
     * @param pyIds 项目类型Id数组
     * @return
     */
    @PostMapping(value = "/delete")
    public R delete(@RequestBody Long[] pyIds) {
        //处理逻辑
        return pmPTypeService.delete(pyIds, cloudUser);
    }

    /**
     * 根据Id查询项目类别
     *
     * @param pyId 项目任务类型编号
     * @return
     */
    @GetMapping(value = "/findById")
    public PmPTypeVO findById(Long pyId) {
        return pmPTypeService.findById(pyId);
    }


    /**
     * 根据Id查询所有项目类别
     *
     * @param pyId
     * @return
     */
    @GetMapping(value = "/getById")
    public PmPType getById(Long pyId) {
        return pmPTypeService.getById(pyId);
    }


    /**
     * 根据项目Id进行删除
     *
     * @param pyId 项目类型Id
     * @return
     */
    @RequestMapping(value = "/deleteById", method = RequestMethod.GET)
    public R deleteById(Long pyId) {
        //处理逻辑
        return pmPTypeService.deleteById(pyId, cloudUser);
    }

    /**
     * 联合查询
     *
     * @param pageNum    当前页码
     * @param pageSize   每页大小
     * @param pmPTypeDTO 项目类型对象
     * @return
     */
    @PostMapping(value = "/findByQuery/{pageNum}/{pageSize}")
    public PageResultVO findByQuery(

            @PathVariable("pageNum") int pageNum,
            @PathVariable("pageSize") int pageSize,
            @RequestBody(required = false) PmPTypeDTO pmPTypeDTO) {
        //校验当前页码是否合理
        pageNum = pageNum <= 0 ? 1 : pageNum;
        //校验每页大小是否合理
        pageSize = pageSize < 5 ? 5 : pageSize;
        return pmPTypeService.findByQuery(pageNum, pageSize, pmPTypeDTO, cloudUser);
    }

    /**
     * 根据项目/任务类型名称查询是否存在
     *
     * @param pyName 项目/任务类型名称
     * @return
     */
    @GetMapping(value = "/findByPyName")
    public ResultVO findByPyName(String pyName) {
        if (pmPTypeService.findByPyName(pyName, cloudUser)) {
            return new ResultVO(true, "项目名称不存在");
        } else {
            return new ResultVO(false, "项目名称已存在");
        }
    }

    /**
     * 新增默认项目任务类型  一同账套项目、任务分别只能有一个默认 同时校验  2020.5.18
     */
    @GetMapping(value = "/insertDefaultType/{pyId}")
    public R insertDefaultType(@PathVariable("pyId") Integer pyId){
        return pmPTypeService.insertDefaultType(pyId,cloudUser);
    }

    /**
     * 取消默认项目任务类型  2020.5.18
     */
    @GetMapping(value = "/updateDefaultType/{pyId}")
    public R updateDefaultType(@PathVariable("pyId") Integer pyId){
        return pmPTypeService.updateDefaultType(pyId,cloudUser);
    }
}
